const SETTINGS = require('@/settings');

/**
 * 假装是个代理方法
 * @param {HttpRequestConfig} config 请求配置
 * @param {String} regExp 代理匹配前缀
 * @param {String} target 代理服务器地址
 * @returns 新的请求配置
 */
function proxy(config, regExp, target) {
    const pattern = new RegExp(regExp);
    if (pattern.test(config.url)) {
        config.url = config.url.replace(pattern, '');
        config.baseURL = target;
    }
    return config;
}

module.exports = vm => {
    /**
     * 初始化请求配置
     */
    uni.$u.http.setConfig((config) => {
        /* config 为默认全局配置 */
        config.baseURL = SETTINGS.baseUrl; /* 根域名 */
        // 设置为json，返回后会对数据进行一次JSON.parse()
        config.dataType = 'json';
        // 配置请求头信息
        config.header = {
            'content-type': 'application/json',
        };

        return config;
    });
    /**
     * 请求拦截器
     */
    uni.$u.http.interceptors.request.use(
        async config => {
            // 多个服务器配置 在这里判断config.url的前缀 修改baseUrl
            config = proxy(config, '^/server_2/', SETTINGS.baseUrl2);
            // 初始化请求拦截器时，会执行此方法，此时data为undefined，赋予默认{}
            config.data = config.data || {};
            config.params = config.params || {};
            config.header = config.header || {};
            // 可以在此通过vm引用vuex中的变量，具体值在vm.$store.state中
            // if (process.env.NODE_ENV === 'development') {
            // 	console.log(vm.$store.state);
            // }


            if (vm.$store.state.user.openid) {
                config.header.openId = vm.$store.state.user.openid;
            }

            return config;
        },
        error => Promise.reject(error),
    );
    /**
     * 响应拦截器
     */
    uni.$u.http.interceptors.response.use(
        async response => {
            /* 对响应成功做点什么 可使用async await 做异步操作*/
            const data = response.data
            // 自定义参数

            const custom = response.config?.custom
            if (response.statusCode !== 200) { // 服务端返回的状态码不等于200，则reject()
                // 如果没有显式定义custom的toast参数为false的话，默认对报错进行toast弹出提示
                if (custom.toast !== false) {
                    uni.$u.toast(data.msg)
                }
                // 如果需要catch返回，则进行reject
                if (custom?.catch) {
                    return Promise.reject(data)
                } else {
                    // 否则返回一个pending中的promise
                    return new Promise(() => {
                    })
                }
            } else {
                if (data.code != 200) {
                    if (data.code == 0) {
                        if (custom.toast !== false && !uni.$u.test.isEmpty(data.msg)) {
                            uni.$u.toast(data.msg)
                        }
                        return Promise.reject(data.msg)
                    } else if (data.code === 401) {
						uni.$u.toast('登录失效,请重新登录')
                        uni.clearStorage();
                        vm.$store.commit('user/saveIsLogin', false);
                        vm.$store.commit('user/saveOpenId', '');
                        vm.$store.commit('user/saveUserInfo', {});
                        uni.navigateTo({
                            url: '/pages/login/login'
                        })
                        return Promise.reject(data.msg)
                    }if (data.code == 505) {
                        // return Promise.reject(data.msg)
                    } else {
                        // if(process.env.NODE_ENV === 'development'){
                        console.log('接口报错了');
                        if (custom.toast !== false && !uni.$u.test.isEmpty(data.msg)) {
                            uni.$u.toast(data.msg)
                        }else{
							 uni.$u.toast('出错了,请联系管理员');
						}
                        // }else{
                        //     uni.$u.toast('参数配置有误')
                        // }
                        return Promise.reject(data.msg)
                    }

                }
            }
            return data || {};
        },
        error => Promise.reject(error) // 可使用async await 做异步操作
    );
};
